home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / distutils / cmd.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  15.9 KB  |  383 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''distutils.cmd
  5.  
  6. Provides the Command class, the base class for the command classes
  7. in the distutils.command package.
  8. '''
  9. __revision__ = '$Id: cmd.py,v 1.39 2004/11/10 22:23:14 loewis Exp $'
  10. import sys
  11. import os
  12. import string
  13. import re
  14. from types import *
  15. from distutils.errors import *
  16. from distutils import util, dir_util, file_util, archive_util, dep_util
  17. from distutils import log
  18.  
  19. class Command:
  20.     '''Abstract base class for defining command classes, the "worker bees"
  21.     of the Distutils.  A useful analogy for command classes is to think of
  22.     them as subroutines with local variables called "options".  The options
  23.     are "declared" in \'initialize_options()\' and "defined" (given their
  24.     final values, aka "finalized") in \'finalize_options()\', both of which
  25.     must be defined by every command class.  The distinction between the
  26.     two is necessary because option values might come from the outside
  27.     world (command line, config file, ...), and any options dependent on
  28.     other options must be computed *after* these outside influences have
  29.     been processed -- hence \'finalize_options()\'.  The "body" of the
  30.     subroutine, where it does all its work based on the values of its
  31.     options, is the \'run()\' method, which must also be implemented by every
  32.     command class.
  33.     '''
  34.     sub_commands = []
  35.     
  36.     def __init__(self, dist):
  37.         """Create and initialize a new Command object.  Most importantly,
  38.         invokes the 'initialize_options()' method, which is the real
  39.         initializer and depends on the actual command being
  40.         instantiated.
  41.         """
  42.         Distribution = Distribution
  43.         import distutils.dist
  44.         if not isinstance(dist, Distribution):
  45.             raise TypeError, 'dist must be a Distribution instance'
  46.         
  47.         if self.__class__ is Command:
  48.             raise RuntimeError, 'Command is an abstract class'
  49.         
  50.         self.distribution = dist
  51.         self.initialize_options()
  52.         self._dry_run = None
  53.         self.verbose = dist.verbose
  54.         self.force = None
  55.         self.help = 0
  56.         self.finalized = 0
  57.  
  58.     
  59.     def __getattr__(self, attr):
  60.         if attr == 'dry_run':
  61.             myval = getattr(self, '_' + attr)
  62.             if myval is None:
  63.                 return getattr(self.distribution, attr)
  64.             else:
  65.                 return myval
  66.         else:
  67.             raise AttributeError, attr
  68.  
  69.     
  70.     def ensure_finalized(self):
  71.         if not self.finalized:
  72.             self.finalize_options()
  73.         
  74.         self.finalized = 1
  75.  
  76.     
  77.     def initialize_options(self):
  78.         '''Set default values for all the options that this command
  79.         supports.  Note that these defaults may be overridden by other
  80.         commands, by the setup script, by config files, or by the
  81.         command-line.  Thus, this is not the place to code dependencies
  82.         between options; generally, \'initialize_options()\' implementations
  83.         are just a bunch of "self.foo = None" assignments.
  84.  
  85.         This method must be implemented by all command classes.
  86.         '''
  87.         raise RuntimeError, 'abstract method -- subclass %s must override' % self.__class__
  88.  
  89.     
  90.     def finalize_options(self):
  91.         """Set final values for all the options that this command supports.
  92.         This is always called as late as possible, ie.  after any option
  93.         assignments from the command-line or from other commands have been
  94.         done.  Thus, this is the place to code option dependencies: if
  95.         'foo' depends on 'bar', then it is safe to set 'foo' from 'bar' as
  96.         long as 'foo' still has the same value it was assigned in
  97.         'initialize_options()'.
  98.  
  99.         This method must be implemented by all command classes.
  100.         """
  101.         raise RuntimeError, 'abstract method -- subclass %s must override' % self.__class__
  102.  
  103.     
  104.     def dump_options(self, header = None, indent = ''):
  105.         longopt_xlate = longopt_xlate
  106.         import distutils.fancy_getopt
  107.         if header is None:
  108.             header = "command options for '%s':" % self.get_command_name()
  109.         
  110.         print indent + header
  111.         indent = indent + '  '
  112.         for option, _, _ in self.user_options:
  113.             option = string.translate(option, longopt_xlate)
  114.             if option[-1] == '=':
  115.                 option = option[:-1]
  116.             
  117.             value = getattr(self, option)
  118.             print indent + '%s = %s' % (option, value)
  119.         
  120.  
  121.     
  122.     def run(self):
  123.         """A command's raison d'etre: carry out the action it exists to
  124.         perform, controlled by the options initialized in
  125.         'initialize_options()', customized by other commands, the setup
  126.         script, the command-line, and config files, and finalized in
  127.         'finalize_options()'.  All terminal output and filesystem
  128.         interaction should be done by 'run()'.
  129.  
  130.         This method must be implemented by all command classes.
  131.         """
  132.         raise RuntimeError, 'abstract method -- subclass %s must override' % self.__class__
  133.  
  134.     
  135.     def announce(self, msg, level = 1):
  136.         """If the current verbosity level is of greater than or equal to
  137.         'level' print 'msg' to stdout.
  138.         """
  139.         log.log(level, msg)
  140.  
  141.     
  142.     def debug_print(self, msg):
  143.         """Print 'msg' to stdout if the global DEBUG (taken from the
  144.         DISTUTILS_DEBUG environment variable) flag is true.
  145.         """
  146.         DEBUG = DEBUG
  147.         import distutils.debug
  148.         if DEBUG:
  149.             print msg
  150.             sys.stdout.flush()
  151.         
  152.  
  153.     
  154.     def _ensure_stringlike(self, option, what, default = None):
  155.         val = getattr(self, option)
  156.         if val is None:
  157.             setattr(self, option, default)
  158.             return default
  159.         elif type(val) is not StringType:
  160.             raise DistutilsOptionError, "'%s' must be a %s (got `%s`)" % (option, what, val)
  161.         
  162.         return val
  163.  
  164.     
  165.     def ensure_string(self, option, default = None):
  166.         """Ensure that 'option' is a string; if not defined, set it to
  167.         'default'.
  168.         """
  169.         self._ensure_stringlike(option, 'string', default)
  170.  
  171.     
  172.     def ensure_string_list(self, option):
  173.         '''Ensure that \'option\' is a list of strings.  If \'option\' is
  174.         currently a string, we split it either on /,\\s*/ or /\\s+/, so
  175.         "foo bar baz", "foo,bar,baz", and "foo,   bar baz" all become
  176.         ["foo", "bar", "baz"].
  177.         '''
  178.         val = getattr(self, option)
  179.         if val is None:
  180.             return None
  181.         elif type(val) is StringType:
  182.             setattr(self, option, re.split(',\\s*|\\s+', val))
  183.         elif type(val) is ListType:
  184.             types = map(type, val)
  185.             ok = types == [
  186.                 StringType] * len(val)
  187.         else:
  188.             ok = 0
  189.         if not ok:
  190.             raise DistutilsOptionError, "'%s' must be a list of strings (got %r)" % (option, val)
  191.         
  192.  
  193.     
  194.     def _ensure_tested_string(self, option, tester, what, error_fmt, default = None):
  195.         val = self._ensure_stringlike(option, what, default)
  196.         if val is not None and not tester(val):
  197.             raise DistutilsOptionError, ("error in '%s' option: " + error_fmt) % (option, val)
  198.         
  199.  
  200.     
  201.     def ensure_filename(self, option):
  202.         """Ensure that 'option' is the name of an existing file."""
  203.         self._ensure_tested_string(option, os.path.isfile, 'filename', "'%s' does not exist or is not a file")
  204.  
  205.     
  206.     def ensure_dirname(self, option):
  207.         self._ensure_tested_string(option, os.path.isdir, 'directory name', "'%s' does not exist or is not a directory")
  208.  
  209.     
  210.     def get_command_name(self):
  211.         if hasattr(self, 'command_name'):
  212.             return self.command_name
  213.         else:
  214.             return self.__class__.__name__
  215.  
  216.     
  217.     def set_undefined_options(self, src_cmd, *option_pairs):
  218.         '''Set the values of any "undefined" options from corresponding
  219.         option values in some other command object.  "Undefined" here means
  220.         "is None", which is the convention used to indicate that an option
  221.         has not been changed between \'initialize_options()\' and
  222.         \'finalize_options()\'.  Usually called from \'finalize_options()\' for
  223.         options that depend on some other command rather than another
  224.         option of the same command.  \'src_cmd\' is the other command from
  225.         which option values will be taken (a command object will be created
  226.         for it if necessary); the remaining arguments are
  227.         \'(src_option,dst_option)\' tuples which mean "take the value of
  228.         \'src_option\' in the \'src_cmd\' command object, and copy it to
  229.         \'dst_option\' in the current command object".
  230.         '''
  231.         src_cmd_obj = self.distribution.get_command_obj(src_cmd)
  232.         src_cmd_obj.ensure_finalized()
  233.         for src_option, dst_option in option_pairs:
  234.             if getattr(self, dst_option) is None:
  235.                 setattr(self, dst_option, getattr(src_cmd_obj, src_option))
  236.                 continue
  237.         
  238.  
  239.     
  240.     def get_finalized_command(self, command, create = 1):
  241.         """Wrapper around Distribution's 'get_command_obj()' method: find
  242.         (create if necessary and 'create' is true) the command object for
  243.         'command', call its 'ensure_finalized()' method, and return the
  244.         finalized command object.
  245.         """
  246.         cmd_obj = self.distribution.get_command_obj(command, create)
  247.         cmd_obj.ensure_finalized()
  248.         return cmd_obj
  249.  
  250.     
  251.     def reinitialize_command(self, command, reinit_subcommands = 0):
  252.         return self.distribution.reinitialize_command(command, reinit_subcommands)
  253.  
  254.     
  255.     def run_command(self, command):
  256.         """Run some other command: uses the 'run_command()' method of
  257.         Distribution, which creates and finalizes the command object if
  258.         necessary and then invokes its 'run()' method.
  259.         """
  260.         self.distribution.run_command(command)
  261.  
  262.     
  263.     def get_sub_commands(self):
  264.         """Determine the sub-commands that are relevant in the current
  265.         distribution (ie., that need to be run).  This is based on the
  266.         'sub_commands' class attribute: each tuple in that list may include
  267.         a method that we call to determine if the subcommand needs to be
  268.         run for the current distribution.  Return a list of command names.
  269.         """
  270.         commands = []
  271.         for cmd_name, method in self.sub_commands:
  272.             if method is None or method(self):
  273.                 commands.append(cmd_name)
  274.                 continue
  275.         
  276.         return commands
  277.  
  278.     
  279.     def warn(self, msg):
  280.         sys.stderr.write('warning: %s: %s\n' % (self.get_command_name(), msg))
  281.  
  282.     
  283.     def execute(self, func, args, msg = None, level = 1):
  284.         util.execute(func, args, msg, dry_run = self.dry_run)
  285.  
  286.     
  287.     def mkpath(self, name, mode = 511):
  288.         dir_util.mkpath(name, mode, dry_run = self.dry_run)
  289.  
  290.     
  291.     def copy_file(self, infile, outfile, preserve_mode = 1, preserve_times = 1, link = None, level = 1):
  292.         """Copy a file respecting verbose, dry-run and force flags.  (The
  293.         former two default to whatever is in the Distribution object, and
  294.         the latter defaults to false for commands that don't define it.)"""
  295.         return file_util.copy_file(infile, outfile, preserve_mode, preserve_times, not (self.force), link, dry_run = self.dry_run)
  296.  
  297.     
  298.     def copy_tree(self, infile, outfile, preserve_mode = 1, preserve_times = 1, preserve_symlinks = 0, level = 1):
  299.         '''Copy an entire directory tree respecting verbose, dry-run,
  300.         and force flags.
  301.         '''
  302.         return dir_util.copy_tree(infile, outfile, preserve_mode, preserve_times, preserve_symlinks, not (self.force), dry_run = self.dry_run)
  303.  
  304.     
  305.     def move_file(self, src, dst, level = 1):
  306.         '''Move a file respectin dry-run flag.'''
  307.         return file_util.move_file(src, dst, dry_run = self.dry_run)
  308.  
  309.     
  310.     def spawn(self, cmd, search_path = 1, level = 1):
  311.         '''Spawn an external command respecting dry-run flag.'''
  312.         spawn = spawn
  313.         import distutils.spawn
  314.         spawn(cmd, search_path, dry_run = self.dry_run)
  315.  
  316.     
  317.     def make_archive(self, base_name, format, root_dir = None, base_dir = None):
  318.         return archive_util.make_archive(base_name, format, root_dir, base_dir, dry_run = self.dry_run)
  319.  
  320.     
  321.     def make_file(self, infiles, outfile, func, args, exec_msg = None, skip_msg = None, level = 1):
  322.         """Special case of 'execute()' for operations that process one or
  323.         more input files and generate one output file.  Works just like
  324.         'execute()', except the operation is skipped and a different
  325.         message printed if 'outfile' already exists and is newer than all
  326.         files listed in 'infiles'.  If the command defined 'self.force',
  327.         and it is true, then the command is unconditionally run -- does no
  328.         timestamp checks.
  329.         """
  330.         if exec_msg is None:
  331.             exec_msg = 'generating %s from %s' % (outfile, string.join(infiles, ', '))
  332.         
  333.         if skip_msg is None:
  334.             skip_msg = 'skipping %s (inputs unchanged)' % outfile
  335.         
  336.         if type(infiles) is StringType:
  337.             infiles = (infiles,)
  338.         elif type(infiles) not in (ListType, TupleType):
  339.             raise TypeError, "'infiles' must be a string, or a list or tuple of strings"
  340.         
  341.         if self.force or dep_util.newer_group(infiles, outfile):
  342.             self.execute(func, args, exec_msg, level)
  343.         else:
  344.             log.debug(skip_msg)
  345.  
  346.  
  347.  
  348. class install_misc(Command):
  349.     '''Common base class for installing some files in a subdirectory.
  350.     Currently used by install_data and install_scripts.
  351.     '''
  352.     user_options = [
  353.         ('install-dir=', 'd', 'directory to install the files to')]
  354.     
  355.     def initialize_options(self):
  356.         self.install_dir = None
  357.         self.outfiles = []
  358.  
  359.     
  360.     def _install_dir_from(self, dirname):
  361.         self.set_undefined_options('install', (dirname, 'install_dir'))
  362.  
  363.     
  364.     def _copy_files(self, filelist):
  365.         self.outfiles = []
  366.         if not filelist:
  367.             return None
  368.         
  369.         self.mkpath(self.install_dir)
  370.         for f in filelist:
  371.             self.copy_file(f, self.install_dir)
  372.             self.outfiles.append(os.path.join(self.install_dir, f))
  373.         
  374.  
  375.     
  376.     def get_outputs(self):
  377.         return self.outfiles
  378.  
  379.  
  380. if __name__ == '__main__':
  381.     print 'ok'
  382.  
  383.